Publishing a Flutter application to the Google Play Store means preparing the application, creating a production-ready Android App Bundle (AAB), configuring Google Play Console, completing the required app information, testing the release, and submitting it for review.
For new Android applications, Google Play uses the Android App Bundle format as the standard publishing format. Flutter provides the flutter build appbundle command for generating the release bundle. :contentReference[oaicite:0]{index=0}
Google Play Store is Google's official distribution platform for Android applications. Developers can publish applications so that users can discover, install, update, and use them on compatible Android devices.
A Flutter application can be developed using Flutter and Dart and then packaged as an Android App Bundle for Google Play distribution.
Flutter Application
↓
Complete Development
↓
Test Application
↓
Prepare Production Configuration
↓
Update Version
↓
Configure Application ID
↓
Configure Release Signing
↓
Build Android App Bundle
↓
Create / Configure Play Console App
↓
Complete Store Listing
↓
Complete App Content Information
↓
Create Testing Release
↓
Test Application
↓
Create Production Release
↓
Submit for Review
↓
Google Play Review
↓
Application PublishedBefore publishing a Flutter application, several development and Google Play requirements should be completed.
Before creating the release build, verify the Flutter development environment.
flutter doctorFor detailed information:
flutter doctor -vAlso verify the Flutter version:
flutter --versionMake sure the project is in a stable state before creating the production build.
flutter pub getflutter pub outdatedflutter clean
flutter pub getNever publish an application without testing the complete production workflow.
A debug build and a release build can behave differently. Therefore, test the application in release mode before publishing.
flutter run --releaseTesting release mode helps identify problems that may not appear during normal debug development.
Flutter applications commonly define their version in pubspec.yaml.
version: 1.0.0+1| Part | Purpose |
|---|---|
| 1 | Major version |
| 0 | Minor version |
| 0 | Patch version |
| 1 | Build number |
version: 1.2.0+10When publishing an update, the Android version code must be greater than the version code of the currently published version. The package name must remain the same and the update must use the appropriate signing identity. :contentReference[oaicite:1]{index=1}
The Android application ID uniquely identifies the application on Google Play.
applicationId = "com.companyname.myapp"Choose the application ID carefully because the package identity is important for future updates.
Application Name: My Flutter Store
Application ID: com.example.mystore
Version: 1.0.0
Build Number: 1The production application should use its final public name.
For Android, review the application label in the manifest:
android:label="My Flutter Store"
android:icon="@mipmap/ic_launcher">
The default Flutter application icon should normally be replaced with the final production icon.
The Android manifest is located at:
android/app/src/main/AndroidManifest.xmlReview application configuration, permissions, activities, services, deep links, and other Android-specific settings before release.
android:label="My Flutter App"
android:icon="@mipmap/ic_launcher">
...
Only request permissions that are required by the application.
| Permission Type | Possible Purpose |
|---|---|
| Internet | API and network communication |
| Camera | Taking photographs or scanning |
| Location | Location-based functionality |
| Notifications | Push or local notifications |
| Media/File Access | Working with files or media where permitted |
Also remember that third-party packages can introduce Android permissions, so review the final application configuration.
Make sure the release application communicates with production services rather than development servers.
http://localhost:3000https://api.example.comBefore publishing, verify:
Android applications distributed through Google Play need to be signed. Flutter's Android release process supports configuring a release signing key, and Google Play App Signing can manage the app signing key for distribution.
android/key.properties
upload-keystore.jksSigning credentials should be kept private and should not be committed to public source control.
The Android App Bundle is the preferred publishing format for Google Play.
flutter build appbundleFlutter creates the release bundle at:
build/app/outputs/bundle/release/app.aabFlutter's documentation identifies App Bundle as the preferred Play Store release format. :contentReference[oaicite:2]{index=2}
| Feature | AAB | APK |
|---|---|---|
| Full Name | Android App Bundle | Android Package |
| Google Play Publishing | Preferred format | Not the standard format for new Play apps |
| Direct Installation | Not normally installed directly | Can be installed directly |
| Optimization | Google Play generates optimized APKs | Developer distributes the APK |
| File Extension | .aab | .apk |
Google Play Console is the platform used to create, configure, test, and publish Android applications on Google Play.
Before publishing, the developer must provide the required developer account information and complete applicable verification and Play Console requirements. :contentReference[oaicite:3]{index=3}
After signing in to Google Play Console, create a new application and provide the initial app information.
After creating the app, Play Console provides a dashboard containing the tasks that must be completed before launch. :contentReference[oaicite:4]{index=4}
The Play Console dashboard guides developers through important setup and publishing tasks.
Play Console
↓
Select Application
↓
Dashboard
↓
Complete App Setup
↓
Testing
↓
Production Release
↓
Review and PublishThe store listing is the information users see when viewing the application on Google Play.
Google recommends that store listing information accurately describe what the application actually does. Misleading descriptions or screenshots can cause problems during review. :contentReference[oaicite:5]{index=5}
Manage your daily tasks with a simple and powerful Flutter application.My Flutter App helps users organize their daily tasks,
track progress, and manage important activities from
a simple mobile interface.
Features:
• Create tasks
• Update tasks
• Mark tasks as completed
• Search tasks
• Organize daily activities
The description should accurately represent the actual functionality of the application.
Screenshots demonstrate the application's user interface and help users understand its functionality before installation.
Select the category that accurately represents the purpose of the application.
The selected category should match the actual functionality of the application.
Provide appropriate contact information so users and Google Play can contact the developer where required.
Applications that collect or process user data may need to provide a privacy policy and complete the applicable Data safety information in Play Console.
The privacy policy should accurately explain how the application collects, uses, stores, and shares user information.
Google Play requires developers to provide applicable privacy policy and Data safety information before submission. :contentReference[oaicite:6]{index=6}
The Data safety section communicates information about how the application collects, shares, and handles user data.
The answers should accurately reflect the application's behavior and the behavior of included SDKs and services.
Google Play requires developers to provide information used to determine the appropriate content rating for an application.
Answer the questionnaire according to the actual content and functionality of the application.
Provide accurate information about the intended audience of the application.
If the application is intended for children or includes children as part of its target audience, additional Google Play requirements may apply.
If reviewers cannot access important functionality without logging in, provide the required review access information.
Demo Email:
[email protected]
Demo Password:
DemoPassword123
Do not use invalid or expired credentials. Google Play requires developers to provide an active demo account and other resources needed for review when app functionality is restricted by login. :contentReference[oaicite:7]{index=7}
Google Play has target API level requirements that change over time. As of August 31, 2026, new apps and app updates generally need to target Android 16 (API level 36) or higher, with separate requirements for certain form factors such as Wear OS and Android TV. :contentReference[oaicite:8]{index=8}
Before publishing, verify the current Google Play target API requirements and configure the Flutter Android project accordingly.
targetSdk = 36The exact configuration should match the Android Gradle setup and current Flutter/Android tooling used by the project.
Testing is an important part of the Google Play publishing process. Play Console provides internal, closed, and open testing tracks before production.
App Bundle
↓
Internal Testing
↓
Closed Testing
↓
Open Testing
↓
ProductionInternal testing is useful for quickly distributing a build to a small group of testers.
Internal testing allows developers to distribute an application to a limited group of testers before making it publicly available.
Google Play currently supports an internal testing track with up to 100 selected testers. :contentReference[oaicite:9]{index=9}
Closed testing allows a selected group of testers to evaluate the application before public release.
It is useful for applications that need more extensive testing than a small internal team can provide.
Personal developer accounts created after November 13, 2023 currently have specific testing requirements before production access. Google Play states that such accounts must run a closed test with at least 12 testers opted in continuously for at least 14 days before applying for production access. :contentReference[oaicite:10]{index=10}
Open testing allows a broader group of users to participate in testing through Google Play.
Users can join the test and provide feedback before the production release.
After completing the required setup and testing, create a production release.
Google Play documents production as a release track available for making the application available to users in selected countries and regions. :contentReference[oaicite:11]{index=11}
The Flutter-generated AAB can be uploaded to the appropriate Play Console release track.
flutter build appbundlebuild/app/outputs/bundle/release/app.aabUpload this production bundle to Play Console after completing release signing and testing.
Release notes explain what is new or improved in the current application version.
Version 1.2.0
• Improved application performance
• Added new task management features
• Improved login experience
• Fixed notification issues
• Improved overall stability
Release notes should describe actual changes in the submitted version.
Before submitting the application, carefully review all information.
Configure whether the application is free or paid and select the countries or regions where the application should be distributed.
Pricing and availability settings should be reviewed carefully because changing some commercial settings later can have additional implications.
After submitting the application, Google Play may review the application and its associated information before it becomes publicly available.
Review time can vary. Google notes that certain developer accounts may receive longer review times, including up to seven days or longer in exceptional cases. :contentReference[oaicite:12]{index=12}
Submitted
↓
In Review
↓
Approved
↓
PublishedIf Google identifies a policy or technical issue, the developer may need to make corrections and submit a new version or updated information.
| Problem | Possible Cause |
|---|---|
| Version code error | Build number is not greater than the previous version |
| Package name issue | Application ID does not match the existing application |
| Signing problem | Incorrect signing configuration |
| Target API problem | Application does not meet current target API requirements |
| Missing privacy information | Required privacy policy or Data safety information is incomplete |
| Login access problem | Reviewers cannot access restricted application functionality |
| Misleading store listing | Screenshots or descriptions do not accurately represent the app |
| Policy issue | Application or content does not comply with Google Play policies |
| Testing requirement | Applicable developer account has not completed required testing |
Publishing an update is different from publishing the first version.
Google Play requires the updated app bundle to use the same package name, a greater version code, and the appropriate signing certificate as the existing application. :contentReference[oaicite:13]{index=13}
version: 1.0.0+1version: 1.1.0+2flutter clean
flutter pub get
flutter build appbundlebuild/app/outputs/bundle/release/app.aabUpload the new AAB to the appropriate Play Console track.
Google Play App Signing is used to manage the app signing key for applications distributed through Google Play.
Developer
↓
Upload Key
↓
Google Play
↓
App Signing Key
↓
Optimized APKs
↓
Users' DevicesKeep the upload keystore and credentials secure even when Play App Signing is enabled.
When an AAB is uploaded, Google Play can generate optimized APKs appropriate for users' devices.
Flutter App
↓
AAB
↓
Google Play Processing
↓
Device-specific APKs
↓
User InstallationThis is one of the main advantages of using the Android App Bundle publishing model.
Play Console provides tools for inspecting uploaded app bundles and the APKs generated from them.
Developers can review version information, supported devices, and generated artifacts through the releases and bundles area of Play Console. :contentReference[oaicite:14]{index=14}
Before publishing, test application stability and performance. Google Play monitors technical quality indicators such as crashes and application-not-responding events.
Applications should be tested thoroughly to avoid production crashes, ANRs, broken functionality, and excessive resource usage. :contentReference[oaicite:15]{index=15}
| Task | Status |
|---|---|
| Flutter project tested | ☐ |
| Release mode tested | ☐ |
| Application name finalized | ☐ |
| Application icon finalized | ☐ |
| Application ID verified | ☐ |
| Version updated | ☐ |
| Build number increased | ☐ |
| Production API configured | ☐ |
| Permissions reviewed | ☐ |
| Firebase configuration checked | ☐ |
| Signing configured | ☐ |
| Keystore protected | ☐ |
| AAB generated | ☐ |
| Store listing completed | ☐ |
| Screenshots uploaded | ☐ |
| Privacy policy completed | ☐ |
| Data Safety completed | ☐ |
| Content rating completed | ☐ |
| Target audience completed | ☐ |
| App access information completed | ☐ |
| Testing completed | ☐ |
| Production release created | ☐ |
| Release notes added | ☐ |
| Final review completed | ☐ |
flutter cleanflutter pub getflutter run --releaseversion: 1.0.0+1flutter build appbundlebuild/app/outputs/bundle/release/app.aabSign in to Play Console and select or create the application.
Complete the required store listing, app content, data safety, content rating, target audience, and other required information.
Upload the AAB to an appropriate testing track and test the application.
After completing the applicable testing and setup requirements, create the production release and submit it through the Play Console workflow.
The Android App Bundle (AAB) is the standard publishing format for new applications on Google Play.
flutter build appbundlebuild/app/outputs/bundle/release/app.aabThe application ID uniquely identifies an Android application and is used by Google Play to identify the application package.
Google Play uses the version code to distinguish newer Android application builds from older builds.
Google Play Console is the platform developers use to configure, test, publish, update, and monitor Android applications distributed through Google Play.
Internal testing allows developers to distribute an application to a small group of testers before wider distribution.
An Android App Bundle is a publishing package containing an application's compiled resources and code. Google Play can use it to generate optimized APKs for users' devices.
Android applications need appropriate digital signing for distribution and updates.
Application identity, version, signing, store listing, privacy information, Data safety, content rating, target audience, testing, permissions, production configuration, and the final AAB should all be reviewed.
Publishing a Flutter application to Google Play Store involves much more than generating an APK. The application should first be tested and prepared for production, configured with the correct application ID and version, digitally signed, and built as an Android App Bundle.
The overall process can be summarized as:
Develop
↓
Test
↓
Prepare Release
↓
Configure Signing
↓
Build AAB
↓
Create Play Console App
↓
Complete Store Listing
↓
Complete App Content
↓
Testing Track
↓
Production Release
↓
Google Play Review
↓
Published AppGoogle Play requirements can change over time, so developers should verify the current Play Console policies, target API requirements, testing requirements, and publishing requirements before submitting each production release. :contentReference[oaicite:16]{index=16}
JustAcademy Flutter Training Course
Register for Flutter Course Demo
